Lấy một ma trận các số nguyên dương làm đầu vào và xuất tổng các phần tử riêng lẻ trên các đường chéo thông qua ma trận.

Bạn sẽ chỉ đếm các dòng đi xuống theo đường chéo và bên phải. Bạn phải bắt đầu với đường chéo chỉ chứa phần tử phía dưới bên trái, sau đó là đường chéo hai chiều dài phía trên (nếu nó tồn tại) và tiếp tục đến đường chéo chỉ chứa phần tử trên cùng bên phải, như minh họa bên dưới.

Thí dụ:

Input:
 8   14    5    1
10    5    5    8
 6    6    8   10
15   15    4   11

Output:
15, 21, 20, 32, 29, 13, 1
(Diagonals: {{15},{6,15},{10,6,4},{8,5,8,11},{14,5,10},{5,8},{1}})

Input:
1
Output:
1

Input: 
1 5
Output:
1, 5

Input:
4
1

Output: 
1, 4

Input:
17    4    5
24   16    5
 9   24   10
 1   14   22
 1   21   24
 4    4   17
24   25   17

Output:
24, 29, 22, 39, 47, 70, 43, 9, 5

Định dạng đầu vào và đầu ra là tùy chọn như mọi khi.

Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

Haskell , 40 37 byte

z=0:z
foldl1$(.(++z)).zipWith(+).(0:)

Hãy thử trực tuyến! Cách sử dụng : (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Chỉnh sửa: Cảm ơn Ørjan Johansen cho -3 byte!

Ung dung:

z = 0:z
s#t = zipWith(+)(0:s)(t++z)
f m = foldl1 (#) m

zlà một danh sách vô số số không. Trong fchúng tôi gấp danh sách các danh sách mbằng cách kết hợp hai danh sách với chức năng #. Trong #danh sách đầu tiên schứa tổng số cột tích lũy cho đến nay và danh sách thứ hai tlà hàng mới cần được thêm vào. Chúng tôi dịch chuyển smột yếu tố sang phải bằng cách thêm số 0 vào phía trước và thêm phần tử thông minh svà tvới zipWith(+). Vì scó thể lớn tùy ý, chúng tôi phải đệm tvới số không đủ bằng cách nối thêm z.

Toán học, 53 54 byte

l=Length@#-1&;Tr@Diagonal[#,k]~Table~{k,-l@#,l@#&@@#}&

Hàm thuần túy lấy một mảng 2D làm đầu vào và trả về một danh sách. (Bài dự thi không phải là số nguyên hoặc số chẵn.) Trả Diagonal[#,k]về kđường chéo thứ trên (hoặc bên dưới, nếu kâm) đường chéo chính. {k,-l@#,l@#&@@#}tính toán phạm vi các đường chéo cần thiết dựa trên kích thước của mảng đầu vào. Và tính Trtổng các mục của mỗi đường chéo.

MATL , 6 byte

T&XdXs

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

T&Xd   % All diagonals of implicit input arranged as zero-padded columns
Xs     % Sum of each column. Implicitly display

Thạch , 5 byte

0;+µ/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

0;+µ/  Main link. Argument: M (matrix / array of rows)

   µ   Combine all links to the left into a chain (arity unknown at parse time) and
       begin a new monadic chain.
    /  Reduce M by that chain. This makes the chain dyadic.
       Let's call the arguments of the chain L and R (both flat arrays).
0;         Prepend a 0 to L.
  +        Perform element-wise addition of the result and R.
           When the chain is called for the n-th time, R has n less elements, so
           the last n elements of L won't have matching elements in R and will be
           left unaltered.

JavaScript (ES6), 65 58 byte

a=>a.map(b=>b.map((c,i)=>r[i]=~~r[i]+c,r=[,...r]),r=[])&&r

CJam , 22 21 byte

Đã lưu 1 byte nhờ Martin Ender

{_,({0\f+}*ee::m<:.+}

Khối ẩn danh mong đợi đối số trên ngăn xếp và để lại kết quả trên ngăn xếp.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

_                   e# Duplicate the matrix
 ,(                 e# Get its length (# of rows) minus 1
   {0\f+}*          e# Prepend that many 0s to each row
          ee        e# Enumerate; map each row to [index, row]
            ::m<    e# Rotate each row left a number of spaces equal to its index
                :.+ e# Sum each column

05AB1E , 17 byte

Rvy¹gÅ0«NFÁ}})øO¨

Hãy thử trực tuyến!

Giải trình

R                  # reverse input
 v                 # for each N,y (index, item)
  y¹gÅ0«           # pad y with as many zeroes as the number of rows in the input
        NFÁ}       # rotate each row N times right
            })     # wrap the result in a list
              øO   # sum the columns
                ¨  # remove the last element of the resulting list (the padded zeroes)

J , 7 byte

+//.@|.

Hãy thử trực tuyến!

Điều này khá đơn giản:

+//.@|.
+/        sum
  /.      on oblique lines
    @|.   on the reversed array

Các đường đảo ngược xiên là các đường chéo của mảng, vì vậy đây chỉ là tổng các đường chéo.

Python 2 , 62 byte

lambda M:reduce(lambda x,y:map(sum,zip([0]+x,y+[0]*len(x))),M)

Hãy thử trực tuyến!

Thạch , 8 byte

ŒDS€ṙZL$

Hãy thử trực tuyến!

Một nửa mã được sử dụng để đưa kết quả vào đúng thứ tự.

Làm sao?

ŒDS€ṙZL$ - Main link: list of lists of numbers
ŒD       - diagonals (starts with the diagonal containing the top left element,
         -            then the next diagonal to the right, and so on wrapping around)
  S€     - sum €each
       $ - last two links as a monad
     Z   - transpose the matrix
      L  - length (width of the matrix)
    ṙ    - rotate the results left by that amount

Perl 5, 47 byte

map{$j=--$.;map{@a[$j++]+=$_}split}<>
print"@a"

R, 45 byte

Hàm không tên lấy một đối tượng lớp ma trận làm đầu vào:

function(x)sapply(split(x,col(x)-row(x)),sum)

Sử dụng ý tưởng giải thích trong câu trả lời này .

Octave, 71 byte

Giả sử A là một ma trận, ví dụ:

A = [17 4 5;24 16 5; 9 24 10; 1 14 22; 1 21 24; 4 4 17;24 25 17];

Sau đó chúng tôi có:

[m,n]=size(A);
a=[zeros(m,m-1),A]';
for i=1:m+n-1
trace(a(i:end,:))
end

Lưu ý rằng hoán vị ma trận đảo ngược thứ tự của các tổng đường chéo, đã lưu tổng cộng hai byte trong vòng lặp for.

Đầu ra:

ans =  24
ans =  29
ans =  22
ans =  39
ans =  47
ans =  70
ans =  43
ans =  9
ans =  5

Python, 126 byte

x=input()
f=lambda k:[x[i+k][i]for i in range(len(x)-k)]
a=map(f,range(4)[::-1])
x=zip(*x)
print(map(sum,a+map(f,range(1,4))))

fchỉ hoạt động trên phần tam giác dưới, vì vậy tôi hoán chuyển nó và có được phần tam giác trên theo cách đó. Không biết tại sao fhàm không hoạt động cho các giá trị âm (tôi đã thay đổi fthành ngắn hơn vì phần để lấy âm bản không hoạt động).

C, 148 byte

Thử trực tuyến

s;g(int i,int j,int**m,int x){for(s=0;x;x--)s+=m[i++][j++];printf(" %d",s);}
k;f(int n,int**m){for(k=n;--k;)g(k,0,m,n-k);for(;k<n;k++)g(0,k,m,n-k);}

PHP, 81 byte

Lấy đầu vào là mảng 2 D

<?foreach($_GET as$k=>$v)foreach($v as$x=>$y)$r[$x-$k]+=$y;ksort($r);print_r($r);

Hãy thử trực tuyến!

Awk, 67 byte

{for(f=0;f++<NF;)s[NF-NR+f]+=$f}END{i=0;while(i++<NR*2)print s[i]}

Ung dung:

{
    for (f = 0; f++ < NF;)
        s[NF-NR+f] += $f
}
END {
    i = 0
    while (i++ < NR*2)
        print s[i]
}

Awk chia nhỏ trên khoảng trắng $nlà trường nthứ (1-index); NFlà số lượng các trường trên dòng, NRlà số của hàng hiện tại. Các biến không xác định là 0 và được tạo trong lần sử dụng đầu tiên.

PHP, 86 byte

một giải pháp thân thiện với bộ nhớ trong hai biến thể:

<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=0,$d=$c;$d--;)$s+=$a[$i+$d][$d];
<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=$d=0;$d<$c;)$s+=$a[$i+$d][$d++];

lấy đầu vào từ các tham số script, sử dụng dấu gạch dưới làm dấu phân cách;
sử dụng cài đặt mặc định (không phải php.ini mặc định) hoặc thử trực tuyến

Clojure, 81 byte

#(apply map +(map(fn[i c](concat(repeat(-(count %)i 1)0)c(repeat i 0)))(range)%))

Khá dài dòng, vì nó liệt kê các số không để chúng ta có thể tính tổng số theo cột.

toán học 73 byte

Plus@@@Table[Diagonal[Partition[#1,#2[[1]]],k],{k,-#2[[2]]+1,#2[[1]]-1}]&

Cái này hoạt động cho MỌI mảng 2D (không chỉ nxn)
nhập vào mảng ở cuối mã như thế này (trường hợp thử nghiệm cuối cùng)

[{17,4,5,24,16,5,9,24,10,1,14,22,1,21,24,4,4,17,24,25,17},{3,7}]

{24, 29, 22, 39, 47, 70, 43, 9, 5}

đầu vào ở dạng [{a, b, c, d ...}, {m, n}]