Weź macierz dodatnich liczb całkowitych jako dane wejściowe i wyślij indywidualne sumy elementów na ukośnych liniach przez macierz.

Policzycie tylko te linie, które idą po przekątnej w dół i w prawo. Musisz zacząć od przekątnej, która zawiera tylko lewy dolny element, potem przekątnej długości dwa powyżej (jeśli istnieje) i tak dalej, aż do przekątnej, która zawiera tylko prawy górny element, jak pokazano poniżej.

Przykład:

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

Formaty wejściowe i wyjściowe są jak zawsze opcjonalne.

To jest gra w golfa , więc wygrywa najkrótsze zgłoszenie w każdym języku.

Haskell , 40 37 bajtów

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

Wypróbuj online! Zastosowanie: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Edycja: Podziękowania dla Ørjan Johansen za -3 bajty!

Nie golfowany:

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

zto lista nieskończenie wielu zer. W fskładamy listę list m, łącząc dwie listy z funkcją #. W #pierwszej listy szawiera nagromadzonych sumy kolumn pory i druga lista tjest nowy rząd, które powinny być dodawane. Przesuwamy sjeden element w prawo, dodając zero z przodu i dodając elementy z soraz . Ponieważ może być dowolnie duży, musimy uzupełnić odpowiednią liczbą zer .tzipWith(+)stz

Mathematica, 53 54 bajty

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

Czysta funkcja przyjmuje tablicę 2D jako dane wejściowe i zwraca listę. (Wpisy nie muszą być liczbami całkowitymi ani parzystymi). Diagonal[#,k]Zwraca kth przekątną powyżej (lub poniżej, jeśli kjest ujemna) głównej przekątnej. {k,-l@#,l@#&@@#}oblicza zakres potrzebnych przekątnych na podstawie wymiarów tablicy wejściowej. I Trsumuje wpisy każdej przekątnej.

MATL , 6 bajtów

T&XdXs

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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

Galaretka , 5 bajtów

0;+µ/

Wypróbuj online!

Jak to działa

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 bajtów

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

CJam , 22 21 bajtów

Zaoszczędzono 1 bajt dzięki Martinowi Enderowi

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

Anonimowy blok oczekuje argumentu na stosie i pozostawia wynik na stosie.

Wypróbuj online!

Jak to działa

_                   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 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

+//.@|.

Wypróbuj online!

To jest dość proste:

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

Ukośne odwrócone linie są przekątnymi tablicy, więc jest to tylko sumowanie przekątnych.

Python 2 , 62 bajty

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

Wypróbuj online!

Galaretka , 8 bajtów

ŒDS€ṙZL$

Wypróbuj online!

Połowa kodu służy do uporządkowania wyników we właściwej kolejności.

W jaki sposób?

Œ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 bajtów

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

R, 45 bajtów

Funkcja bez nazwy przyjmująca obiekt klasy macierzy jako dane wejściowe:

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

Wykorzystując pomysł wyjaśniony w tej odpowiedzi.

Oktawa, 71 bajtów

Zakładając, że A jest macierzą, na przykład:

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

Potem będzie:

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

Zauważ, że transpozycja macierzy odwraca kolejność sum diagonalnych, co pozwoliło zaoszczędzić ogółem dwa bajty w pętli for.

Wynik:

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

Python, 126 bajtów

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

fdziała tylko na dolnym trójkątnym odcinku, więc transponuję go i otrzymam w ten sposób górny trójkątny odcinek. Nie wiem, dlaczego ta ffunkcja nie działa dla wartości ujemnych (zmieniłem się fna krótszy, ponieważ część polegająca na uzyskaniu negatywów nie działała).

C, 148 bajtów

Wypróbuj online

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 bajtów

Weź dane wejściowe jako tablicę 2 D.

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

Wypróbuj online!

Awk, 67 bajtów

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

Nie golfowany:

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

Awk dzieli się na białe znaki $nto npole th (1-indeksowane); NFto liczba pól w linii, NRto liczba bieżącego wiersza. Niezdefiniowane zmienne mają wartość 0 i są tworzone przy pierwszym użyciu.

PHP, 86 bajtów

rozwiązanie przyjazne pamięci w dwóch wariantach:

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

pobiera dane wejściowe z parametrów skryptu, używa podkreślnika jako separatora;
użyj ustawień domyślnych (nie domyślnego php.ini) lub wypróbuj je online

Clojure, 81 bajtów

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

Całkiem gadatliwy, ponieważ uzupełnia listy zerami, dzięki czemu możemy po prostu obliczyć sumę według kolumn.

matematyka 73 bajty

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

Ten działa dla KAŻDEJ tablicy 2D 2D (nie tylko nxn)
wprowadź tablicę na końcu kodu w ten sposób (ostatni przypadek testowy)

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

dane wejściowe w formie [{a, b, c, d ...}, {m, n}]