Suma las diagonales


19

Tome una matriz de enteros positivos como entrada y envíe las sumas individuales de los elementos en las líneas diagonales a través de la matriz.

Solo contarás las líneas que van diagonalmente hacia abajo y hacia la derecha. Debe comenzar con la diagonal que contiene solo el elemento inferior izquierdo, luego la diagonal de longitud dos por encima de eso (si existe) y así sucesivamente hasta la diagonal que contiene solo el elemento superior derecho, como se ilustra a continuación.

Ejemplo:

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

Los formatos de entrada y salida son opcionales como siempre.

Este es el , por lo que gana la presentación más corta en cada idioma.


Respuestas:


6

Haskell , 40 37 bytes

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

Pruébalo en línea! Uso: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Editar: ¡ Gracias a Ørjan Johansen por -3 bytes!

Sin golf:

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

zes una lista de infinitos ceros. En fplegamos la lista de listas mcombinando dos listas con la función #. En #la primera lista scontiene las sumas de columnas acumuladas hasta ahora y la segunda lista tes la nueva fila que debe agregarse. Cambiamos sun elemento a la derecha agregando un cero al frente y sumando sy tcon elementos zipWith(+). Debido a que spuede ser arbitrariamente grande, tenemos que rellenar tcon ceros suficientes agregando z.


Eso es más corta libre de punto: foldl1$(.(++z)).zipWith(+).(0:).
Ørjan Johansen

6

Mathematica, 53 54 bytes

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

Función pura que toma una matriz 2D como entrada y devuelve una lista. (Las entradas no tienen que ser números enteros o pares). Diagonal[#,k]Devuelve la kdiagonal th arriba (o abajo, si kes negativa) la diagonal principal. {k,-l@#,l@#&@@#}calcula el rango de diagonales necesarias según las dimensiones de la matriz de entrada. Y Trsuma las entradas de cada diagonal.


Alternativa en el mismo conteo de bytes, pero ¿tal vez pueda seguir jugando golf? Esos paréntesis se ven mal. Tr@Diagonal[m,#]&/@Range@@({-1,1}(Dimensions[m=#]-1))&
Martin Ender

5

MATL , 6 bytes

T&XdXs

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Solo curiosidad: ¿Crees que sería mejor en general tener s==sum(x(:)), en lugar de apegarte a la convención MATLAB, como parece hacer MATL?
Stewie Griffin

@StewieGriffin A veces he pensado en eso. Mi duda era más entre sum(x)y sum(x,1). Para una matriz x, el hecho de que se sum(x)comporte de manera diferente si la matriz tiene 1 fila es a veces molesto. Pero al final decidí ir con Matlab, por lo que los dos idiomas están más cerca; y agregue algunas fun(x,1)funciones para los casos más comunes
Luis Mendo

5

Jalea , 5 bytes

0;+µ/

Pruébalo en línea!

Cómo funciona

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.

Solo la primera R para reducir tiene un elemento menos; aumenta en un elemento más cada fila.
Ørjan Johansen

Esto es inteligente ... ŒD¿ no ?
Erik the Outgolfer

@EriktheOutgolfer Una vez más, ŒDlos raros pedidos impidieron que fuera útil.
Dennis

@ Dennis Entonces creo que haría algo que no tiene un orden tan extraño ... oh, tal vez 3 mónadas podrían estar entrando.
Erik the Outgolfer

5

JavaScript (ES6), 65 58 bytes

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

Variante de 63 bytes:a=>a.map(r=>r.map(v=>s[i]=~~s[i++]+v,i=--y),s=[],y=a.length)&&s
Arnauld,

@Arnauld Estoy de acuerdo, invertir fue un mal movimiento. ¡Pero tomar la longitud también es demasiado largo!
Neil

3

CJam , 22 21 bytes

Guardado 1 byte gracias a Martin Ender

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

Bloque anónimo que espera el argumento en la pila y deja el resultado en la pila.

Pruébalo en línea!

Cómo funciona

_                   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

2

05AB1E , 17 bytes

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

Pruébalo en línea!

Explicación

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)

2

J , 7 bytes

+//.@|.

Pruébalo en línea!

Esto es bastante simple:

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

Las líneas oblicuas invertidas son las diagonales de la matriz, por lo que esto es solo sumar las diagonales.



1

Jalea , 8 bytes

ŒDS€ṙZL$

Pruébalo en línea!

La mitad del código se usa para poner los resultados en el orden correcto.

¿Cómo?

Œ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

1

Perl 5, 47 bytes

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

1

R, 45 bytes

Función sin nombre que toma un objeto de clase matriz como entrada:

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

Usando la idea explicada en esta respuesta.


Creo que las reglas en este desafío te permiten deshacerte de la llamada unname, ¡pero esta es una solución increíble!
Giuseppe

1

Octava, 71 bytes

Suponiendo que A es una matriz, por ejemplo:

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

Entonces tenemos:

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

Observe que la transposición de la matriz invierte el orden de las sumas diagonales, lo que ahorró un total de dos bytes en el bucle for.

Salida:

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

1
[m,n]=size(A);for i=1:m+n-1,trace([zeros(m-1,m);A'](i:end,:)),endahorra 6 bytes. Octave puede hacer indexación directa y asignaciones en línea. Desafortunadamente, no se permite suponer que existe una variable en el espacio de trabajo antes de ejecutar el código, por lo que creo que debe usarlo input, de esta manera, lo devuelve a 75 bytes. Buen enfoque, así que +1 de mi parte :) ¡Y bienvenidos a PPCG! =)
Stewie Griffin

Además, zeros(m-1,m)se puede escribir ~e(m-1,m), ahorrando 4 bytes :) Neat huh?
Stewie Griffin

0

Python, 126 bytes

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

fsolo funciona en la sección triangular inferior, así que la transpongo y obtengo la sección triangular superior de esa manera. No sé por qué la ffunción no funciona para valores negativos (cambié fpara que sea más corta porque la parte para obtener los negativos no funcionó).


Me sale un error para el último caso de prueba. tio.run/nexus/…
Dennis

0

C, 148 bytes

Probar en línea

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


0

Awk, 67 Bytes

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

Sin golf:

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

Awk se divide en espacios en blanco $nes el ncampo th (1 indexado); NFes el número de campos en la línea, NRes el número de la fila actual. Las variables no definidas son 0 y se crean en el primer uso.


0

PHP, 86 bytes

Una solución amigable con la memoria en dos variantes:

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

toma datos de los parámetros del script, usa guiones bajos como delimitador;
use la configuración predeterminada (no predeterminada php.ini) o pruébela en línea


0

Clojure, 81 bytes

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

Muy detallado, ya que rellena las listas con ceros para que podamos calcular la suma de columnas.


0

Mathica 73 bytes

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

Este funciona para CUALQUIER matriz 2D mxn (no solo nxn)
ingrese la matriz al final del código de esta manera (el último caso de prueba)

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

entrada en forma [{a, b, c, d ...}, {m, n}]

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.