Sum of elements below main diagonal of matrix: Difference between revisions

{{trans|Nim}}

 

V result = 0

L(i) 1 .< m.len

[ 7, 1, 3, 9, 5]]

 

 

{{out}}

 

=={{header|Action!}}==

BYTE x,y

INT v

sum=SumBelowDiagonal(m,5)

PrintF("Sum below diagonal is %I",sum)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_elements_below_main_diagonal_of_matrix.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Numerics.Generic_Real_Arrays;

 

Put (Sum, Exp => 0, Aft => 1);

New_Line;

{{out}}<pre>Sum below diagonal: 69.0</pre>

 

=={{header|ALGOL 68}}==

# returns the sum of the elements below the main diagonal #

# of m, m must be a square matrix #

)

)

{{out}}

<pre>

=={{header|ALGOL W}}==

One of the rare occasions where the lack of lower/upper bound operators in Algol W actually simplifies things, assuming the programmer gets things right...

% returns the sum of the elements below the main diagonal %

% of m, m must have bounds lb :: ub, lb :: ub %

write( i_w := 1, lowerSum( m, 1, 5 ) )

end

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> matrix ← 5 5⍴1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5

 

=={{header|AutoHotkey}}==

,[2,4,16,14,4]

,[3,1,9,18,11]

. "`nsum below diagonal = " sumB

. "`nsum on diagonal = " sumD

{{out}}

<pre>sum above diagonal = 111

 

=={{header|AWK}}==

# syntax: GAWK -f SUM_OF_ELEMENTS_BELOW_MAIN_DIAGONAL_OF_MATRIX.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

dim diag = {{ 1, 3, 7, 8,10}, { 2, 4,16,14, 4}, { 3, 1, 9,18,11}, {12,14,17,18,20}, { 7, 1, 3, 9, 5}}

ind = diag[?,]

 

print "Sum of elements below main diagonal of matrix is "; sumDiag

 

==={{header|FreeBASIC}}===

{ 1, 3, 7, 8,10}, _

{ 2, 4,16,14, 4}, _

 

Print "Sum of elements below main diagonal of matrix is"; sumDiag

{{out}}

<pre>Sum of elements below main diagonal of matrix is 69</pre>

 

==={{header|GW-BASIC}}===

20 DATA 2,4,16,14,4

30 DATA 3,1,9,18,11

100 NEXT COL

110 NEXT ROW

{{out}}<pre>69</pre>

==={{header|QBasic}}===

{{works with|QuickBasic|4.5}}

{{trans|FreeBASIC}}

 

DIM diag(1 TO 5, 1 TO 5)

DATA 3, 1, 9,18,11

DATA 12,14,17,18,20

 

==={{header|True BASIC}}===

{{trans|FreeBASIC}}

LET lenDiag = UBOUND(diag, 1)

LET ind = lenDiag

 

PRINT "Sum of elements below main diagonal of matrix:"; sumDiag

 

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

lenDiag = arraysize(diag(),1)

ind = lenDiag

data 3, 1, 9,18,11

data 12,14,17,18,20

 

 

=={{header|BQN}}==

 

matrix ← >⟨⟨ 1, 3, 7, 8,10⟩,

⟨ 7, 1, 3, 9, 5⟩⟩

 

{{out}}

<pre>69</pre>

=={{header|C}}==

Interactive program which reads the matrix from a file :

#include<stdlib.h>

#include<stdio.h>

return 0;

}

 

Input Data file, first row specifies rows and columns :

 

=={{header|C++}}==

#include <vector>

 

std::cout << sum_below_diagonal(matrix) << std::endl;

return 0;

{{out}}

<pre>69</pre>

 

{{Works with|Office 365 betas 2021}}

LAMBDA(matrix,

LET(

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

// Sum below leading diagnal. Nigel Galloway: July 21st., 2021

let _,n=[[ 1; 3; 7; 8;10];

[12;14;17;18;20];

[ 7; 1; 3; 9; 5]]|>List.fold(fun(n,g) i->let i,_=i|>List.splitAt n in (n+1,g+(i|>List.sum)))(0,0) in printfn "%d" n

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

 

: sum-below-diagonal ( matrix -- sum )

{ 12 14 17 18 20 }

{ 7 1 3 9 5 }

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

}

fmt.Println("Sum of elements below main diagonal is", sum)

 

{{out}}

Defining both upper and lower triangle of a square matrix:

 

 

matrixTriangle :: Bool -> [[a]] -> Either String [[a]]

]

)

{{Out}}

<pre>Lower triangle:

 

=={{header|J}}==

{{out}}

<pre> mat

 

=={{header|Java}}==

int[][] matrix = {{1, 3, 7, 8, 10},

{2, 4, 16, 14, 4},

}

System.out.println(sum);

{{Out}}

<pre>69</pre>

Defining the lower triangle of a square matrix.

 

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>69</pre>

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def add(s): reduce s as $x (null; . + $x);

 

def sum_below_diagonal:

add( range(0;length) as $i | .[$i][:$i][] ) ;

The task:

[2,4,16,14,4],

[3,1,9,18,11],

[12,14,17,18,20],

[7,1,3,9,5]]

{{out}}

<pre>

the components of the matrix A to the left and below the main diagonal. tril(A, -1) returns the lower triangular

elements of A excluding the main diagonal. The excluded elements of the matrix are set to 0.

 

A = [ 1 3 7 8 10;

 

@show sum(tril(A, -1)) # 69

tril(A) = [1 0 0 0 0; 2 4 0 0 0; 3 1 9 0 0; 12 14 17 18 0; 7 1 3 9 5]

tril(A, -1) = [0 0 0 0 0; 2 0 0 0 0; 3 1 0 0 0; 12 14 17 0 0; 7 1 3 9 0]

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>69</pre>

 

=={{header|MiniZinc}}==

% Sum below leading diagnal. Nigel Galloway: July 22nd., 2021

array [1..5,1..5] of int: N=[|1,3,7,8,10|2,4,16,14,4|3,1,9,18,11|12,14,17,18,20|7,1,3,9,5|];

int: res=sum(n,g in 1..5 where n>g)(N[n,g]);

output([show(res)])

{{out}}

<pre>

We use a generic definition for the square matrix type. The compiler insures that the matrix we provide is actually square.

 

 

func sumBelowDiagonal[T, N](m: SquareMatrix[T, N]): T =

[ 7, 1, 3, 9, 5]]

 

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

 

my $lowersum = sum map @{ $matrix->[$_] }[0 .. $_ - 1], 1 .. $#$matrix;

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">constant</span> <span style="color: #000000;">M</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">8</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">},</span>

<span style="color: #0000FF;">{</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">16</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">14</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">},</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">res</span>

You could of course start row from 2 and get the same result, for row==1 the col loop iterates zero times.<br>

Without the checks for square M expect (when not square) wrong/partial answers for height<=width+1, and (still human readable) runtime crashes for height>width+1.

</pre>

=={{header|PL/I}}==

trap: procedure options (main); /* 17 December 2021 */

declare n fixed binary;

end;

end trap;

{{out}}

<pre>

=={{header|PL/M}}==

This can be compiled with the original 8080 PL/M compiler and run under CP/M or an emulator/clone.

 

/* CP/M BDOS SYSTEM CALL, IGNORE THE RETURN VALUE */

CALL PR$NUMBER( LOWER$SUM( .T, 5 ) );

 

{{out}}

<pre>

 

=={{header|Python}}==

 

A = [[1,3,7,8,10],

[7,1,3,9,5]]

 

 

 

Or, defining the lower triangle for ourselves:

 

 

from itertools import chain, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>69</pre>

=={{header|R}}==

R has lots of native matrix support, so this is trivial.

c(2,4,16,14,4),

c(3,1,9,18,11),

c(12,14,17,18,20),

c(7,1,3,9,5))

{{out}}

<pre>[1] 69</pre>

=={{header|Raku}}==

 

 

say lower-triangle-sum

[ 12, 14, 17, 18, 20 ],

[ 7, 1, 3, 9, 5 ]

{{out}}

<pre>69</pre>

=={{header|REXX}}==

=== version 1 ===

ml ='1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5'

Do i=1 To 5

End

End

<pre>

1 3 7 8 10

This REXX version makes no assumption about the size of the matrix, &nbsp; and it determines the maximum width of any

<br>matrix element &nbsp; (instead of assuming a width that might not properly show the true value of an element).

$= '1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5'; #= words($)

do siz=1 while siz*siz<#; end /*determine the size of the matrix. */

say _ /*display a row of the matrix to term. */

end /*c*/

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

=={{header|Ring}}==

see "working..." + nl

see "Sum of elements below main diagonal of matrix:" + nl

see "" + sumDiag + nl

see "done..." + nl

{{out}}

<pre>

 

=={{header|Ruby}}==

[ 1, 3, 7, 8, 10],

[ 2, 4, 16, 14, 4],

]

p arr.each_with_index.sum {|row, x| row[0, x].sum}

{{out}}

<pre>69

 

=={{header|Seed7}}==

 

const proc: main is func

end for;

writeln(sum);

 

{{out}}

 

=={{header|Wren}}==

[ 1, 3, 7, 8, 10],

[ 2, 4, 16, 14, 4],

}

}

 

{{out}}

 

=={{header|XPL0}}==

[Mat:= [[1,3,7,8,10],

[2,4,16,14,4],

Sum:= Sum + Mat(Y,X);

IntOut(0, Sum);

 

{{out}}