Antecedentes

Los deltas de una matriz de enteros son la matriz formada al obtener las diferencias de elementos consecutivos. Por ejemplo, [1, 2, 4, 7, 3, 9, 6]tiene las siguientes deltas: [1, 2, 3, -4, 6, -3].

Ahora definiremos los deltas de una matriz de enteros como los deltas de cada fila y cada columna que contiene.

Como ejemplo:

Row deltas:

1 2 3 4 │ => [1, 1, 1]
4 5 6 7 │ => [1, 1, 1]
7 1 8 2 │ => [-6, 7, -6]

Column deltas (the matrix' columns have been rotated into rows for simplicity):

1 4 7 │ => [3, 3] 
2 5 1 │ => [3, -4]
3 6 8 │ => [3, 2]
4 7 2 │ => [3, -5]

Lo que nos da la siguiente lista de deltas matriciales:

[[1, 1, 1], [1, 1, 1], [-6, 7, -6], [3, 3], [3, -4], [3, 2], [3, -5]]

Y como no queremos que estén anidados, aplanamos esa lista:

[1, 1, 1, 1, 1, 1, -6, 7, -6, 3, 3, 3, -4, 3, 2, 3, -5]

Tarea

Su tarea es sumar todos los deltas de una matriz dada como entrada. Tenga en cuenta que la matriz solo consistirá en enteros no negativos.

Reglas

• Se aplican todas las reglas estándar.

• Puede suponer que la matriz contiene al menos dos valores en cada fila y columna, por lo que el tamaño mínimo será 2x2 .

• Puede tomar la matriz en cualquier formato razonable, siempre que la especifique.

• No puede suponer que la matriz es cuadrada.

• Si puede ayudarlo a reducir su recuento de bytes, también puede tomar el número de filas y el número de columnas como entrada (¡Mirándolo C!).

• Este es el código de golf, por lo que gana el código más corto (en bytes) en cada idioma .

Casos de prueba

Entrada => Salida

[[1, 2], [1, 2]] => 2
[[8, 7, 1], [4, 1, 3], [5, 5, 5]] => -9
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => 24
[[9, 9, 9, 9, 9], [9, 9, 9, 9, 9]] => 0
[[1, 3, 14], [56, 89, 20], [99, 99, 99]] => 256
[[1, 2, 3, 4], [4, 5, 6, 7], [7, 1, 8, 2]] => 9
[[13, 19, 478], [0, 12, 4], [45, 3, 6], [1, 2, 3]] => -72

Python 2 , 42 bytes

lambda m:sum(r[-1]-r[0]for r in m+zip(*m))

Una función sin nombre que toma una lista de listas my devuelve el número resultante.

Pruébalo en línea!

¿Cómo?

La suma de los deltas de una lista es el último elemento menos el primero, todo lo demás simplemente cancela:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Los zip(*m)usos desembalaje ( *) de mpasar a las filas de mcomo argumentos distintos zip(de intercalación) y por lo tanto transpone la matriz. En python 2, esto produce una lista (de tuplas, pero está bien), por lo que podemos agregar (concatenar) a (con) m, recorrer todas nuestras filas y columnas r, realizar el truco anterior para cada uno y simplemente sumar los resultados ( sum(...))

R , 34 bytes

function(m)sum(diff(m),diff(t(m)))

Pruébalo en línea!

Función anónima. Originalmente, solía apply(m,1,diff)obtener los diferenciales de rowwise (y en 2lugar de 1columnas), pero mirando la respuesta de Stewie Griffin lo probé solo diffy funcionó.

Octava , 33 bytes

@(x)sum([diff(x)(:);diff(x')(:)])

Pruébalo en línea!

Explicación:

Esta es una función anónima que toma xcomo entrada. Toma la diferencia entre todas las columnas y la concatena con la diferencia entre las columnas de la transpuesta de x. Luego suma este vector a lo largo de la segunda dimensión.

Jalea , 5 bytes

;ZIẎS

Pruébalo en línea!

También hay un par de versiones solo ASCII: ;ZIFS ;ZISS

JavaScript (ES6), 68 67 bytes

m=>m.map(r=>s+=[...l=r].pop()-r[0],s=0)|m[0].map(v=>s+=l.pop()-v)|s

Formateado y comentado

m =>                              // given a matrix m
  m.map(r =>                      // for each row r of m
    s += [...l = r].pop() - r[0], //   add to s: last value of r - first value of r
    s = 0                         //   starting with s = 0
  ) |                             //
  m[0].map(v =>                   // for each value v in the first row of m:
    s += l.pop() - v              //   add to s: last value of last row of m - v
  ) |                             //
  s                               // return s

Debido a que el tamaño mínimo de la matriz de entrada es 2x2, m.map(...)|m[0].map(...)se garantiza que se coaccionará 0. Por eso es seguro devolver el resultado final con|s .

Casos de prueba

let f =

m=>m.map(r=>s+=[...l=r].pop()-r[0],s=0)|m[0].map(v=>s+=l.pop()-v)|s

console.log(f( [[1, 2], [1, 2]]                                   )) // => 2
console.log(f( [[8, 7, 1], [4, 1, 3], [5, 5, 5]]                  )) // => -9
console.log(f( [[1, 2, 3], [4, 5, 6], [7, 8, 9]]                  )) // => 24
console.log(f( [[9, 9, 9, 9, 9], [9, 9, 9, 9, 9]]                 )) // => 0
console.log(f( [[1, 3, 14], [56, 89, 20], [99, 99, 99]]           )) // => 256
console.log(f( [[1, 2, 3, 4], [4, 5, 6, 7], [7, 1, 8, 2]]         )) // => 9
console.log(f( [[13, 19, 478], [0, 12, 4], [45, 3, 6], [1, 2, 3]] )) // => -72

MATL , 7 bytes

dG!dhss

Pruébalo en línea!

Explicación:

Supongamos que la entrada es

[8 7 1; 4 1 3; 5 5 5]

d        % Difference between rows of input
         % Stack:
         % [-4 -6  2; 1  4  2]
 G       % Grab the input again. Stack:
         % [-4 -6  2; 1  4  2]
         % [8 7 1; 4 1 3; 5 5 5]]
  !      % Transpose the bottom element. Stack:
         % [-4 -6  2; 1  4  2]
         % [8 4 5; 7 1 5; 1 3 5]
   d     % Difference between rows. Stack:
         % [-4 -6  2; 1  4  2]
         % [-1 -3  0; -6  2  0]
    h    % Concatenate horizontally. Stack:
         % [-4 -6  2 -1 -3  0; 1  4  2 -6  2  0]
     ss  % Sum each column, then sum all column sums. Stack:
         % -9

05AB1E , 6 bytes

ø«€¥OO

Utiliza la codificación 05AB1E . Pruébalo en línea!

J , 14 bytes

+/@,&({:-{.)|:

Pruébalo en línea!

Explicación

+/@,&({:-{.)|:  Input: matrix M
            |:  Transpose
     (     )    Operate on M and M'
      {:          Tail
        -         Minus
         {.       Head
   ,&           Join
+/@             Reduce by addition

Casco , 7 bytes

ΣṁẊ-S+T

Pruébalo en línea!

-1 gracias al Sr. Xcoder tomando mi atención lejos de la Sy ¤, y hacia el m(que debería haber sido ṁ).
-1 gracias al abuso de ZgarbS .

Explicación:

ΣṁẊ-S+T 3-function composition
    S   (x -> y -> z) (f) -> (x -> y) (g) -> x (x) (implicit): f x g x
     +    f: [x] (x) -> [x] (y) -> [x]: concatenate two lists
      T   g: [[x]] (x) -> [[x]]: transpose x
 ṁ      (x -> [y]) (f) -> [x] (x) -> [y]: map f on x and concatenate
  Ẋ       f: (x -> y -> z) (f) -> [x] (x) -> [z]: map f on splat overlapping pairs of x
   -        f: TNum (x) -> TNum (y) -> TNum: y - x
Σ       [TNum] (x) -> TNum: sum x

APL, 18 15 bytes

{-+/∊2-/¨⍵(⍉⍵)}

Pruébalo en línea!

Haskell , 60 bytes

e=[]:e
z=zipWith
f s=sum$(z(-)=<<tail)=<<(s++foldr(z(:))e s)

Pruébalo en línea! Utiliza la transposición más corta que encontré hace un tiempo.

Explicación

ees una lista infinita de listas vacías y se utiliza para la transposición. zes una abreviatura de la zipWithfunción, porque se usa dos veces.

f s=                                        -- input s is a list of lists
                            foldr(z(:))e s  -- transpose s
                         s++                -- append the result to the original list s
                     =<<(                 ) -- map the following function over the list and concatenate the results
        (z(-)=<<tail)                       -- compute the delta of each list by element-wise subtracting its tail
    sum$                                    -- compute the sum of the resulting list

Brachylog , 13 bytes

Originalmente basado en el diseño @ sundar

⟨≡⟨t-h⟩ᵐ²\⟩c+ 

Explicación

⟨≡      \⟩          #   Take the original matrix and it's transpose 
      ᵐ             #       and execute the following on both
       ²            #           map for each row (this is now a double map "ᵐ²")
  ⟨t h⟩             #               take head and tail
   -                #               and subtract them from each other (sum of deltas in a row)
         c+         #       and add all the values 
                    #           (we have two arrays of arrays so we concat them and sum them)

el ⟨⟩ están arruinando el formato, lo siento

Pruébalo en línea!

Pyth, 7 bytes

ss.+M+C

Pruébalo aquí

¡Mi primera respuesta en un idioma de golf! Gracias a @EriktheOutgolfer por -1 byte!

Explicación

ss.+M+C    ~ This is a full program with implicit input (used twice, in fact)

      C    ~ Matrix transpose. Push all the columns;
     +     ~ Concatenate with the rows;
  .+M      ~ For each list;
  .+       ~ Get the deltas;
 s         ~ Flatten the list of deltas;
s          ~ Get the sum;
           ~ Print Implicitly;

Brachylog , 22 16 bytes

⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ

Pruébalo en línea!

(-6 bytes inspirados en las sugerencias de @ Kroppeb).

?⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ.       Full code (? and . are implicit input and output)
?⟨≡{       }ᵐ\⟩          Apply this on both the input and its transpose:
    s₂ᶠ                  Get pairs of successive rows, [[row1, row2], [row2, row3], ...]
       c                 Flatten that: [row1, row2, row2, row3, row3, row4, ...]
        +ᵐ               Sum the elements within each row [sum1, sum2, sum2, sum3, ...]
          -              Get the difference between even-indexed elements (starting index 0)
                         and odd-indexed elements, i.e. sum1+sum2+sum3+... - (sum2+sum3+sum4+...)
                         This gets the negative of the usual difference i.e. a-b instead of b-a
                         for each pair of rows
               +         Add the results for the input and its transpose
                ṅ        Negate that to get the sign correct
                 .       That is the output

Japt -x , 11 10 9 bytes

cUy)®än x

Intentalo

Explicación

c             :Concatenate
 U            :  Input array
  y           :  Transpose
   )          :End concatenation
    ®         :Map
     än       :  Deltas
        x     :  Reduce by addition
              :Implicitly reduce by addition and output

SOGL V0.12 , 9 bytes

:⌡-≤H⌡-¹∑

Pruébalo aquí! ( →agregado porque esto toma entrada en la pila)

Explicación:

:          duplicate ToS
 ⌡         for each do
  -          get deltas
   ≤       get the duplicate ontop
    H      rotate it anti-clockwise
     ⌡     for each do
      -      get deltas
       ¹   wrap all of that in an array
        ∑  sum

Mathematica, 45 bytes

Tr@Flatten[Differences/@#&/@{#,Transpose@#}]&

Entrada

[{{13, 19, 478}, {0, 12, 4}, {45, 3, 6}, {1, 2, 3}}]

CJam , 19 bytes

0q~_z+2few:::-:+:+-

La entrada es una lista de listas de números. Pruébalo en línea!

Explicación

0       e# Push 0
q~      e# Evaluated input. 
_       e# Duplicate
z       e# Zip (transpose)
+       e# Concatenate. This gives a lists of lists of numbers, where the
        e# inner lists are the original rows and the columns
2few    e# Replace each inner list of numbers by a list of overlapping
        e# slices of size 2. We not have three-level list nesting
:::-    e# Compute difference for each of those size-two slices. We now
        e# have the deltas for each row and column
:+      e# Concatenate all second-level lists (de-nest one level)
:+      e# Sum all values
-       e# Subtract from 0, to change sign. Implicitly display

MI, 9 bytes

ωΔω⍉Δ ḟΣ↵

Pruébalo en línea!

Como no puedo hacer ping a Dennis en el chat para extraer MY (debido a una suspensión), actualmente no funcionará. (Δ anteriormente no vecificaba al restar) ¡ Gracias a quien consiguió que Dennis tirara de MI!

¿Cómo?

• ωΔ, incrementos del primer argumento de línea de comando
• ω⍉Δ, incrementos de la transposición del primer argumento de línea de comando
• , en una sola lista
• ḟaplanar
• Σsuma
• ↵, salida

APL (Dyalog Classic) , 12 bytes

(+/⊢⌿,⊣/)⌽-⊖

Pruébalo en línea!

Pyt , 11 bytes

Đ⊤ʁ-⇹ʁ-áƑƩ~

Explicación:

          Implicit input (as a matrix)
Đ         Duplicate the matrix
⊤         Transpose the matrix
ʁ-        Get row deltas of transposed matrix
⇹         Swap top two elements on the stack
ʁ-        Get row deltas of original matrix
á         Push the stack into an array
Ƒ         Flatten the array
Ʃ         Sum the array
~         Flip the sign (because the deltas are negative, as subtraction was performed to obtain them)
          Implicit output