Giriş olarak pozitif tamsayıların bir matrisini alın ve matris boyunca diyagonal çizgilerdeki elemanların münferit toplamlarını çıkarın.

Sadece çaprazlama aşağı ve sağa doğru giden çizgileri sayacaksınız. Yalnızca sol alt öğeyi içeren diyagonal ile başlamalısınız, daha sonra (varsa) üstündeki iki uzunluk diyagonal ile aşağıda gösterildiği gibi yalnızca sağ üst öğeyi içeren diyagonalden başlamalısınız.

Misal:

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

Giriş ve çıkış formatları her zamanki gibi isteğe bağlıdır.

Bu kod golf , bu yüzden her dilde en kısa teslim kazanmak kazanır.

Haskell , 40 37 bayt

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

Çevrimiçi deneyin! Kullanımı: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Düzenleme: -3 bayt için Ørjan Johansen'a teşekkürler!

Ungolfed:

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

zsonsuz sayıda sıfırın bir listesidir. Burada f, miki listeyi işlevle birleştirerek listeler listesi üzerinde katlanırız #. Olarak #birinci listeden skadar birikmiş kolon miktarda içerir ve ikinci liste teklenmelidir yeni satırdır. Biz vardiya sön ve öğeye göre eklenti bir sıfır ekleyerek sağa bir eleman sve tile zipWith(+). Çünkü skeyfi büyük olabilir, biz pad zorunda tekleyerek yeterli sıfırlarla z.

Mathematica, 53 54 bayt

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

Bir 2D diziyi giriş olarak alan ve bir liste döndüren saf işlev. (Girişlerin tamsayı veya çift sayı olması gerekmez.) Ana diyagonalin üstündeki (veya negatifse alttaki) diyagonali Diagonal[#,k]döndürür . girdi dizisinin boyutlarına göre gereken köşegen aralığını hesaplar. Ve her bir diyagonalin girişlerini toplar.kk{k,-l@#,l@#&@@#}Tr

MATL , 6 bayt

T&XdXs

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

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

Jöle , 5 bayt

0;+µ/

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

CJam , 22 21 bayt

Martin Ender sayesinde 1 bayt kurtarıldı

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

Anonim blok yığındaki bağımsız değişkeni bekler ve sonucu yığına bırakır.

Çevrimiçi deneyin!

Nasıl çalışır

_                   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 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

+//.@|.

Çevrimiçi deneyin!

Bu oldukça basit:

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

Eğik ters çizgiler dizinin köşegenleridir, bu sadece köşegenleri toplamaktır.

Python 2 , 62 bayt

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

Çevrimiçi deneyin!

Jöle , 8 bayt

ŒDS€ṙZL$

Çevrimiçi deneyin!

Kodun yarısı, sonuçları doğru sıraya koymak için kullanılır.

Nasıl?

Œ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 bayt

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

R, 45 bayt

Matrix sınıfı bir nesneyi girdi olarak alan adsız işlev:

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

Bu cevapta açıklanan fikri kullanarak .

Oktav, 71 bayt

A'nın bir matris olduğunu varsayalım, örneğin:

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

Sonra elimizde:

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

Matrisin transpozisyonunun, for döngüsünde toplam iki bayt kaydeden diyagonal toplamların sırasını tersine çevirdiğine dikkat edin.

Çıktı:

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

Python, 126 bayt

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))))

fsadece alt üçgen kısımda çalışır, bu yüzden onu aktarırım ve üst üçgen kısmı bu şekilde alırım. fFonksiyonun neden negatif değerler için çalışmadığını bilmiyorum ( fdaha kısa olarak değiştim çünkü negatifleri alma kısmı işe yaramadı).

C, 148 bayt

Çevrimiçi Deneyin

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 Bayt

Girişi 2 D Dizi Olarak Al

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

Çevrimiçi deneyin!

Awk, 67 Bayt

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

Ungolfed:

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

Awk boşluk böler $nolan ninci alanı (1 endeksli); NFsatırdaki NRalan sayısı, geçerli satırın sayısıdır. Tanımsız değişkenler 0'dır ve ilk kullanımda oluşturulur.

PHP, 86 bayt

iki çeşit bellek dostu çözüm:

<?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++];

kod parametrelerinden girdi alır, ayırıcı olarak alt çizgi kullanır;
varsayılan ayarları kullanın (varsayılan php.ini değil) veya çevrimiçi deneyin

Clojure, 81 bayt

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

Sütun toplamı hesaplayabilmemiz için sıfırlarla listeler gibi oldukça ayrıntılı.

mathematica 73 bayt

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

Bu
, kodun sonundaki diziyi (son test durumu) herhangi bir 2D dizi mxn (sadece nxn değil) girişi için çalışır

[{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}

[{a, b, c, d ...}, {m, n}] biçiminde girdi